开发者需要了解的MongoDB知识点

1. 基础概念

1.1 database

数据库，一个数据仓库可以包含多个集合

1.2 collection

集合，类似于关系数据库中的表。一个集合可以包含多个文档。

capped collection（限制集合）：设定空间上线，循环写入，新数据覆盖旧数据

1.3 document

文档，一个文档保存着一份数据记录。

1.3.1 数据校验

一个集合下的文档，不会默认要求它们具有相同的数据模式。也就是说，同一个集合下的多个文档：1.字段可以不同；2.同名字段的类型可以不同；相反，如果对文档数据类型有要求，可以在创建集合时设置validator（例如使用JSON schema）来限制集合下文档的数据类别。

1.3.2 文档格式

文档使用BSON来存储，BSON是JSON的二进制表现形式，因此可以适应更多的数据类型。
存储在文档的数据格式，与JSON类似，以键值对的形式存储。
默认主键_id，为ObjectId类型。

2. 基本的CRUD方法

2.1 插入数据

2.1.1 单条插入

使用insert_one()方法

book = {
    'name': 'computer_science',
    'page': 238,
}
result = db.books.insert_one(book)
_id = result.inserted_id    # 返回插入项的id，类型为ObjectId

2.1.2 多条插入

使用insert_many()方法

results = db.collection_name.insert_many([document1, document2, ...])
id_list = results.inserted_ids    # 返回插入项的id列表，列表元素为ObjectId

2.1.3 废弃的插入方法

从pymongo3.0版本开始，已经不推荐使用insert()方法插入数据，虽然它能同时满足单条或多条数据的处理需求。
官方建议使用insert_one()和insert_many()来执行替代操作

2.2 查询数据

假设预先执行了数据插入：

db.inventory.insert_many([
    {"item": "journal",
     "qty": 25,
     "size": {"h": 14, "w": 21, "uom": "cm"},
     "status": "A"},
    {"item": "notebook",
     "qty": 50,
     "size": {"h": 8.5, "w": 11, "uom": "in"},
     "status": "A"},
    {"item": "paper",
     "qty": 100,
     "size": {"h": 8.5, "w": 11, "uom": "in"},
     "status": "D"},
    {"item": "planner",
     "qty": 75, "size": {"h": 22.85, "w": 30, "uom": "cm"},
     "status": "D"},
    {"item": "postcard",
     "qty": 45,
     "size": {"h": 10, "w": 15.25, "uom": "cm"},
     "status": "A"}])

2.2.1 基本查询操作

2.2.1.1 查询所有数据

使用find()方法执行查询，返回游标cursor
查询所有记录时，find()内的filter参数为空

cursor = db.inventory.find({})

上述查询，类似于关系数据库SQL语句：

SELECT * FROM inventory

2.2.1.2 等价条件查询

cursor = db.inventory.find({"status": "D"})

上述查询语句，类似于关系数据库SQL语句：

SELECT * FROM inventory WHERE status = "D"

2.2.1.3 复合条件查询（使用查询操作符查询）

1. 包含(IN)关系查询

cursor = db.inventory.find({"status": {"$in": ["A", "D"]}})

上述查询语句，类似于关系数据库SQL语句：

SELECT * FROM inventory WHERE status in ("A", "D")

1. 与(AND)关系查询

cursor = db.inventory.find({"status": "A", "qty": {"$lt": 30}})

上述查询语句，类似于关系数据库SQL语句：

SELECT * FROM inventory WHERE status = "A" AND qty < 30

1. 或(OR)关系查询

cursor = db.inventory.find({"$or": [{"status": "A"}, {"qty": {"$lt": 30}}]})

上述查询语句，类似于关系数据库SQL语句：

SELECT * FROM inventory WHERE status = "A" OR qty < 30

1. 在查询中同时使用AND和OR

cursor = db.inventory.find({
    "status": "A",
    "$or": [{"qty": {"$lt": 30}}, {"item": {"$regex": "^p"}}]})

上述查询语句，类似于关系数据库SQL语句：

SELECT * FROM inventory WHERE status = "A" AND ( qty < 30 OR item LIKE "p%")

2.2.2 查询操作符

查询操作符定义了查询条件，如：大于、等于、小于等，以下是整理的查询操作符及说明：

比较操作符	说明
$eq	等于
$gt	大于
$gte	大于等于
$in	包含
$lt	小于
$lte	小于等于
$ne	不等于
$nin	不包含于

逻辑操作符	说明
$and	与
$not	非
$nor	或非
$or	或

元素操作符	说明
$exists	指定field存在
$type	指定field的type

查看field的type类型说明

其他操作符说明请见：Query and Projection Operators

2.2.3 嵌套文档查询

对于文档中存在的嵌套结构的查询,可以对文档中的嵌套结构进行 匹配查询 ，也可以对嵌套内容中的某个字段进行 嵌套字段查询

假设文档数据如下：

from bson.son import SON
db.inventory.insert_many([
    {"item": "journal", # 物品名称
     "qty": 25,    # 数量
     "size": SON([("h", 14), ("w", 21), ("uom", "cm")]), # 嵌套结构（高度，宽度，度量单位）
     "status": "A"}, # 状态
    {"item": "notebook",
     "qty": 50,
     "size": SON([("h", 8.5), ("w", 11), ("uom", "in")]),
     "status": "A"},
    {"item": "paper",
     "qty": 100,
     "size": SON([("h", 8.5), ("w", 11), ("uom", "in")]),
     "status": "D"},
    {"item": "planner",
     "qty": 75,
     "size": SON([("h", 22.85), ("w", 30), ("uom", "cm")]),
     "status": "D"},
    {"item": "postcard",
     "qty": 45,
     "size": SON([("h", 10), ("w", 15.25), ("uom", "cm")]),
     "status": "A"}])

1. 对嵌套结构进行匹配查询

from bson.son import SON
cursor = db.inventory.find(
    {"size": SON([("h", 14), ("w", 21), ("uom", "cm")])})
# 上述查询语句中的filter条件，需要完全匹配嵌套文档中的内容，否则无法查询到相关记录。

1. 对嵌套结构中的字段进行查询

mongo使用点表示法指定文档中的嵌套字段："field.nested_field"

# 查询嵌套字段uom的值为cm的记录
cursor = db.inventory.find({"size.uom": "cm"})

# 使用操作符查询高度大于10的记录
cursor = db.inventory.find({"size.h": {"$gt": 10}})

# 多个字段的复合查询
cursor = db.inventory.find(
    {"size.h": {"$lt": 15}, "size.uom": "in", "status": "D"})

2.2.4 数组类型查询

假设向collection中插入如下数据

db.inventory.insert_many([
    {"item": "journal",
     "qty": 25,
     "tags": ["blank", "red"],
     "dim_cm": [14, 21]},
    {"item": "notebook",
     "qty": 50,
     "tags": ["red", "blank"],
     "dim_cm": [14, 21]},
    {"item": "paper",
     "qty": 100,
     "tags": ["red", "blank", "plain"],
     "dim_cm": [14, 21]},
    {"item": "planner",
     "qty": 75,
     "tags": ["blank", "red"],
     "dim_cm": [22.85, 30]},
    {"item": "postcard",
     "qty": 45,
     "tags": ["blue"],
     "dim_cm": [10, 15.25]}])

与2.2.3中嵌套文档查询类似，可以对整个数组进行 匹配查询 ， 也可以对数组中的某个元素进行查询

1. 匹配整个数组

cursor = db.inventory.find({"tags": ["red", "blank"]})

1. 查询数组中的某个元素

# 所有tags中包含red元素的数组都会被查询到
cursor = db.inventory.find({"tags": "red"})

# 对数组中某个元素进行条件查询
# dim_cm中任意一个元素大于25的记录查询
cursor = db.inventory.find({"dim_cm": {"$gt": 25}})

1. 数组元素的复合条件查询

查询dim_cm中的某个元素能同时满足大于15小于20的查询条件的记录
或者 dim_cm中的一个元素大于15，并且存在另一个元素小于20的记录

#  这种查询是不限制单个数组元素的，多个数组元素分别满足查询条件亦可
cursor = db.inventory.find({"dim_cm": {"$gt": 15, "$lt": 20}})

若要指定数组中某一个元素满足多个查询条件，需要使用 __$elemMatch__操作符来进行查询

# 查询数组中存在某一个元素同时满足大于22并且小于30
cursor = db.inventory.find(
    {"dim_cm": {"$elemMatch": {"$gt": 22, "$lt": 30}}})

1. 根据数组索引位置查询

查询dim_cm的第一个元素大于25的记录

cursor = db.inventory.find({"dim_cm.1": {"$gt": 25}})

1. 根据数组长度查询

查询数组长度是否符合查询条件，需要使用 $size 操作符
查询所有tags长度等于3的的记录

cursor = db.inventory.find({"tags": {"$size": 3}})

2.2.5 数组内的嵌套文档查询

假设向collection中插入如下数据：

from bson.son import SON
db.inventory.insert_many([
    {"item": "journal",
     "instock": [
         SON([("warehouse", "A"), ("qty", 5)]),
         SON([("warehouse", "C"), ("qty", 15)])]},
    {"item": "notebook",
     "instock": [
         SON([("warehouse", "C"), ("qty", 5)])]},
    {"item": "paper",
     "instock": [
         SON([("warehouse", "A"), ("qty", 60)]),
         SON([("warehouse", "B"), ("qty", 15)])]},
    {"item": "planner",
     "instock": [
         SON([("warehouse", "A"), ("qty", 40)]),
         SON([("warehouse", "B"), ("qty", 5)])]},
    {"item": "postcard",
     "instock": [
         SON([("warehouse", "B"), ("qty", 15)]),
         SON([("warehouse", "C"), ("qty", 35)])]}])

可以看到instock数组内部每一个元素都是一个嵌套文档。对这类数据的查询方法，是2.2.3嵌套文档查询和2.2.4数组类型查询的结合。

1. 对数组内某个嵌套文档进行 匹配查询

# 匹配查询对于嵌套文档内的field顺序有要求，
# 查询结果只展示与查询条件中field排列顺序相同的记录。
cursor = db.inventory.find(
    {"instock": SON([("warehouse", "A"), ("qty", 5)])})

1. 对数组内的嵌套文档字段进行 条件查询

# 查询所有文档中，instock数组中至少有一个元素的qty值大于20的记录
cursor = db.inventory.find({'instock.qty': {"$lte": 20}})

1. 对数组形式的嵌套文档按照 数组索引查询

# 查询所有文档中，instock数组的第0个嵌套文档元素中，qty的值小于等于20的所有记录
cursor = db.inventory.find({'instock.0.qty': {"$lte": 20}})

1. 使用 $elemMatch 对数组内的某个嵌套文档进行复合查询

# 数组内的某个文档同时满足qty=5并且warehouse值为A的查询条件
cursor = db.inventory.find(
    {"instock": {"$elemMatch": {"qty": 5, "warehouse": "A"}}})

# 数组内的某个文档的qty值大于10并且小于等于20
cursor = db.inventory.find(
    {"instock": {"$elemMatch": {"qty": {"$gt": 10, "$lte": 20}}}})

2.2.6 指定查询结果返回的field

MonogDB返回的查询结果，默认包含文档中所有的field，使用者可以通过让mongo返回指定的field，来限制返回内容的数量。

查询表达式如下：

# 返回指定的field
cursor = db.inventory.find(
    {"status": "A"}, {"item": 1, "status": 1, "size.uom": 1})

# 不返回指定的field
cursor = db.inventory.find({"status": "A"}, {"size.uom": 0, "status": 0})

# 对于数组形式的field，指定只返回最后一个元素（使用$slice操作符）
cursor = db.inventory.find(
    {"status": "A"},
    {"instock": {"$slice": -1}})

2.2.7 查询空值和field是否存在

1. 查询item为空或item字段不存在

cursor = db.inventory.find({"item": None})

1. 只查询字段为空的记录
   type值参照

# type值为10时表示的是null类型
cursor = db.inventory.find({"item": {"$type": 10}})

1. 查询某字段不存在

# 查询所有文档中，没有item字段的记录
cursor = db.inventory.find({"item": {"$exists": False}})

2.3 更新数据

MongoDB提供了一系列的操作符来帮助完成文档数据更新，具体说明可查看链接：https://docs.mongodb.com/manu...

2.3.1 更新单个文档

使用pymongo的update_one方法

db.inventory.update_one(
    {"item": "paper"}, # filter筛选条件, 只更新符合该条件的第一条数据
    {"$set": {"size.uom": "cm", "status": "P"},
     "$currentDate": {"lastModified": True}}) # 数据更新表达式，使用$set操作符来更新数据

2.3.2 更新多个文档

使用pymongo的update_many()方法

db.inventory.update_many(
    {"qty": {"$lt": 50}}, # filter筛选条件，更新符合该条件的所有数据
    {"$set": {"size.uom": "in", "status": "P"},
     "$currentDate": {"lastModified": True}})# 数据更新表达式，同样使用$set操作符来更新数据

2.3.3 替换文档

使用pymongo的replace()方法

注：替换方法只替换除_id以外的其他字段

db.inventory.replace_one(
    {"item": "paper"}, # filter筛选条件，替换符合该条件的第一条数据
    {"item": "paper", # 替换后的文档数据
     "instock": [
         {"warehouse": "A", "qty": 60},
         {"warehouse": "B", "qty": 40}]})

2.3.4 upsert选项

不论是update_one()方法还是update_many()方法，亦或是replace_one()方法，都包含upsert:bool 选项，当upsert为True时，这些方法将具备在filter未筛选到文档时，执行文档插入的能力。

2.4 删除数据

pymongo提供了delete_one()和delete_many()两种方法执行删除操作。其中，delete_one()方法一次执行一条文档的删除任务，delete_manyI()可执行多条文档删除任务。

db.inventory.delete_one({"status": "D"}) # 删除符合status值为D的第一条数据
db.inventory.delete_many({"status": "A"}) # 删除符合status值为A的所有数据

值得一提的是，删除操作并不会改变collection的索引设置，即便删除了这个collection下的所有文档。

2.5 批量写入

pymongo提供了批量写入方法：bulk_write()，类似于redis中的pipe_line，它可以将多个写入操作作为一个list参数传入，然后一起执行。它支持insert、update、replace、delete的多种方法，以下是官方文档提供的示例：

try {
   db.characters.bulkWrite(
      [
         { insertOne :
            {
               "document" :
               {
                  "_id" : 4, "char" : "Dithras", "class" : "barbarian", "lvl" : 4
               }
            }
         },
         { insertOne :
            {
               "document" :
               {
                  "_id" : 5, "char" : "Taeln", "class" : "fighter", "lvl" : 3
               }
            }
         },
         { updateOne :
            {
               "filter" : { "char" : "Eldon" },
               "update" : { $set : { "status" : "Critical Injury" } }
            }
         },
         { deleteOne :
            { "filter" : { "char" : "Brisbane"} }
         },
         { replaceOne :
            {
               "filter" : { "char" : "Meldane" },
               "replacement" : { "char" : "Tanys", "class" : "oracle", "lvl" : 4 }
            }
         }
      ]
   );
}
catch (e) {
   print(e);
}

3. 数据模型

3.1 基础知识

3.1.1 灵活的模式

1）同一个集合下，不同文档的字段可以不一致；同一个集合下，不同文档的相同字段，类型可以不一致；
2）可以通过对一个文档的字段进行增删改操作，或是变更字段类型，来改变文档的结构。

3.1.2 文档结构

1) __嵌入式文档结构__，即在一个文档内，可以嵌套子文档内容，实现逻辑相关的数据结构嵌套组合。嵌套式文档结构如下：

# 用户信息表
{
    _id: ObjectId_1,
    username: "youjia",
    sex: "man",
    age: 29,
    contact: { # 嵌入式文档
        phone: [phone],
        email: "[e-mail]",
    }
}

2) __引用式__，不同类型数据使用id引用进行关联，上例可变为：

# 用户表
{
    _id: ObjectId_1,
    username: "youjia",
    sex: "man",
    age: 29,

}

# 联系信息表（原嵌入式文档）
{
    _id: ObjectId_2,
    user_id: ObjectId_1, # 对应用户表_id
    phone: [phone],
    email: "[e-mail]",
}

3.1.3 原子性的写入操作

1) 对一个文档的写入操作是原子性的，即使这个写入操作包含了对嵌套文档的数据写入。
2) 由于对嵌套文档的写入动作是原子性的，因此嵌套式的文档结构设计，更加促进了写入操作原子化，提高了写入效率和数据一致性。
3) 当执行类似updateMany等操作时，虽然只执行了一条指令，但其内部执行过程实际上包含了对多个文档的原子操作。因此这类批量执行指令是非原子性的。
4) 由于对多个文档的批量指令执行是非原子性的，因此在对多个文档进行写入操作时，写入任务可能与其他批量写入任务交叉。
5) 从MongoDB4.0开始，为了保证多文档写入/读取数据的一致性，加入了多表操作事务
6) 多表操作事务相比单表操作，会造成大的多的性能消耗，因此官方仍然认为，在多数情况下 __嵌入式文档结构是更好的选择__。

3.1.4 数据模型校验

官方提供了多种数据模型校验的方法，包括：1. JSON Schema校验，2. 查询表达式校验。官方推荐使用前者。
一个典型的JSON Schema语法示例：

db.createCollection("students", {
   validator: {
      $jsonSchema: {
         bsonType: "object",
         required: [ "name", "year", "major", "gpa" ],
         properties: {
            name: {
               bsonType: "string",
               description: "must be a string and is required"
            },
            gender: {
               bsonType: "string",
               description: "must be a string and is not required"
            },
            year: {
               bsonType: "int",
               minimum: 2017,
               maximum: 3017,
               exclusiveMaximum: false,
               description: "must be an integer in [ 2017, 3017 ] and is required"
            },
            major: {
               enum: [ "Math", "English", "Computer Science", "History", null ],
               description: "can only be one of the enum values and is required"
            },
            gpa: {
               bsonType: [ "double" ],
               minimum: 0,
               description: "must be a double and is required"
            }
         }
      }
   }
})

关于JSON Schema的更详细信息，可参照网上教程：https://spacetelescope.github...

3.2 模型设计原则

3.2.1 设计原则概述

3.1.1中介绍了模型的两种设计结构：__嵌入式文档结构__，和 引用式 文档结构。在设计数据模型时，要考虑根据不同情况选择适合的文档结构进行设计。

3.2.1.1 选择嵌套式文档结构

以下情况下适合使用嵌入式文档结构：

1) 两类数据是一对一并且具有包含关系。例如：用户个人信息-用户联系信息
2) 两类数据时一对多关系，但是在应用过程中通常两类数据需要联合查询使用，使用“一”时通常会查询“多”。

• 嵌套式文档结构的优点：

  • 嵌套式文档结构提供了更好的读性能，数据查询可在一个集合内完成而不必跨集合查询。
  • 降低了数据写入消耗，数据不必多文档写入，一次数据写入任务可以在一个文档内完成，仅执行一次原子性操作。

注意：MongoDB默认限制单个文档大小最大为16MB，因此单个文档大小不能无限扩大。Mongo提供了其他大体量数据的存储方式：GridFS

3.2.1.2 选择引用式文档结构

以下情况适合使用引用式文档结构：

1) 当采用嵌套式文档结构时，被嵌套的数据会有大量重复，并且大量重复数据造成影响大于嵌套文档的优势时，选择引用式文档结构时更好的选择。
2) 要设计“多对多”关系时。
3) 为大型分层数据集建模时。

• 引用式文档的优点：

  • 相比嵌套式结构，多组数据的关系更加解耦。
  • 更适应多对多的关系场景。

3.2.1.3 模型设计中的其他考虑因素

• 原子性操作数量是影响数据库操作性能的主要因素之一，多数情况下，嵌入式文档结构可以有效降低数据库操作成本，提高性能。
• 多文档引用关系下的跨文档操作，会提高操作成本。
• 多文档数据操作，涉及到读写数据一致性问题，需要用到事务(4.0以后版本)。事务的使用会带来明显的性能消耗。
• 对读操作较多的文档设置索引可以提升查询性能，索引设置在查询较多的字段上，主键_id默认设置了索引。
• 索引对写操作的性能有影响。
• 索引会占用一定的数据空间，影响内存和磁盘的空间使用。
• 单个文档存储的数据量过大时，会影响数据库操作请求往返的时间和带宽消耗。
• 单个文档不要超过16MB，过于小的文档模型会浪费存储空间。
• 小文档可以通过缩短filed名称长度来降低存储空间消耗。
• 对于没有持久化需求的数据，可以设置集合属性为“限制集合capped collection”来控制集合大小。

4. 索引

对于查询需求较多的文档，可以通过在适合的字段建立索引来提高查询效率。但是对文档建立过多的索引，会影响写入效率，增加磁盘和内存的空间使用率。

4.1 索引类型

4.1.1 单字段索引

对文档内单个字段建立索引，称为单字段索引。适合对文档内单个字段有频繁查询请求的场景。

db.person.createIndex( {id_no: 1} )

{id_no: 1}代表升序索引，{id_no: -1}代表降序索引，在单字段索引类型下，升序与降序没有区别。

4.1.2 复合索引

复合索引是对多个字段联合创建一个索引。适合对文档内某些字段有频繁查询请求，以及查询与排序请求并存的业务场景。

db.person.createIndex( {age: 1, name: 1} )

创建符合索引时，field的顺序是有关系的。索引将按照第一个field进行升序/降序排列，在此基础上，再对第二个field进行升序/降序排列，以此类推。

4.1.3 多key索引

当索引的字段为数组时，创建出的索引称为多key索引，多key索引会为数组的每个元素建立一条索引，比如person表加入一个habbit字段（数组）用于描述兴趣爱好，需要查询有相同兴趣爱好的人就可以利用habbit字段的多key索引。

//文档格式
{"name" : "jack", "age" : 19, habbit: ["football, runnning"]}

// 自动创建多key索引
db.person.createIndex( {habbit: 1} )  
db.person.find( {habbit: "football"} )

4.2 索引属性

4.2.1 唯一索引

保证索引对应的字段不会出现相同的值，文档主键_id的索引，就是唯一索引。

4.2.2 TTL索引

可以针对某个时间字段，指定文档的过期时间（经过指定时间后过期 或 在某个时间点过期）

4.2.3 部分索引

只针对符合某个特定条件的文档建立索引，比如某字段值大于5，或者某字段值符合某正则表达式，才建立索引，注意：3.2版本才支持该特性.

4.2.4 稀疏索引

只针对存在索引字段的文档建立索引，可看做是部分索引的一种特殊情况

4.3 索引使用注意事项

4.3.1 创建索引

• 选择查询需求较多的文档创建索引；
• 文档中索引创建数量不宜过多，过多的索引会影响写入速度，占用磁盘和内存空间。
• 根据查询场景，选择合适的索引类型。
• 在已填满数据的集合里创建索引，要设置background选项为True，否则在创建过程中会阻塞所有对该集合的读写请求，直至索引创建完成。因此在已有数据的集合内创建索引时，要谨慎。

4.3.2 选择合适的索引

• 单字段索引

  • 对文档内的某个字段有频繁的查询需求
  • 对文档内的某个字段有频繁的排序需求
  • 单字段索引创建，可以不关心索引是升序还是降序的，这对单字段索引没有影响
  • 可以通过“点标法”对文档的内嵌文档中的字段建立索引

• 复合索引

  • 对文档内的某些字段有频繁的查询需求，并且查询需求通常是针对多个字段同时进行的
  • 对文档内的某些字段同时有查询和排序需求，并且查询排序需求通常是同时针对多个字段进行的
  • 创建复合索引时，需根据查询场景选择各字段的索引是升序还是降序。例如：

  # 创建索引
  db.collection.create_index( { "x" : 1, "y" : -1 } )
  
  # 支持下列查询/排序
  db.collection.find().sort( { "x": 1, "y": -1 } )
  db.collection.find().sort( { "x": -1, "y": 1 } )
  
  # 对下列查询/排序，索引不生效
  db.collection.find().sort( { "x": 1, "y": 1 } )

  • 根据业务场景需求，选择合适的索引前缀（字段索引顺序），后缀的索引是在前缀索引的基础上建立的。前缀索引可以作为单独的索引字段查询，但是后缀的索引不可以这样应用。例如：

  # 创建索引
  db.collection.create_index( { "x" : 1, "y" : 1 , "z": 1} )
  
  # 支持对下列查询/排序场景
  db.collection.find().sort({"x": 1})
  db.collection.find().sort({"x": 1, "y": 1})
  db.collection.find().sort({"x": 1, "z": 1}) # 效率较低
  db.collection.find().sort({"x": 1, "y": 1, "z": 1})
  
  # 不支持下列查询/排序场景
  db.collection.find().sort({"y": 1})
  db.collection.find().sort({"z": 1})
  db.collection.find().sort({"y": 1, "z": 1})

• 多key索引

  • 针对数组类型的field创建索引，即为多key索引，创建方式与单key索引一样，当field的数组元素为内嵌文档时，可以对内嵌文档的字段建立多key索引。
  • 一个文档只允许存在一个多key索引。当此文档存在多个array类型的field时，只能针对其中一个field建立多key索引。
  • 复合索引中，可以允许一个文档下存在一个多key索引，而不要求一定是某个field。例如：

  # 创建复合索引
  db.collection.create_index( { "x" : 1, "y" : 1 } )
  
  # 索引支持的文档
  { "x" : 1, "y" : [1,2,3] }
  {"x": [1,2,3], "y": 1}
  
  # 不支持的情况
  {"x": [1,2,3], "y": [1,2,3]}

  • 可以对array内的嵌入式文档的某个field建立索引。例如：

  # 文档结构
  {
      "x": "test",
      "y": 1,
      "z": [
          {"a": 1, "b": "test"},
          {"a": 2, "b": "some"},
          ...
      ],
  }
  
  # 建立嵌入式文档的多key索引
  db.collection_name.create_index({"z.a": 1, "z.b": -1})